#include "my_output_wave.h"



#define HF_ONE_WAVE_PERIOD  (25)


/********** HF负载检测****************/ 
/***********， 人体接触电极头时 约为700~800 ， 短路时超过 ：1500 *******
 * 纪武的皮肤阻抗：
 *      轻压时，刚接触480欧姆，---接触1min降为400欧姆，---接触2min降为 380欧姆
 * 
 * 群测时，
 *      最小皮肤阻抗 轻压时，刚接触 250欧姆左右，重压时130欧姆左右 
 *                   
 *      1组电极接触时 平均阻值668欧， 最小值
 *    
 *    空载时，空载值约为200一下
 *    带载时 
 *           8Ω，  adc的值约为 1930~1950
 *           16Ω   adc约为1800~1900
 *           25Ω时，adc约为1700   
 *           50Ω时， adc值 1500左右 
 *           100Ω时，adc值 1100左右 
 *          
 *           200欧姆时，adc的值约为 900欧
 *           500Ω时，  adc值为 500~ 600 左右
 *  
 *    人体胶后,直接触1 组电极片时，adc值约为  450以下
 *                  2组电极片时，adc值约为   750以下
 * 20241016，测试自己的阻值，
 *      接触3组电极片时140欧姆左右
 *      接触4组电极片时120欧姆足有
 * 
 ******************************************************************/ 
 
// #define MIN_LOAD_ADC_VAL         (500)
// #define MIN_LOAD_ADC_VAL         800//(1000)     // 防止高周波烫伤（接触2个电极片时）【实测，2个电极片时，电压值较低】
// #define MIN_LOAD_ADC_VAL         700//(1000)     // 2024 1021 林总  体验时，不易接触到，就改为700
// #define MIN_LOAD_ADC_VAL         550//(1000)     // 2024 10 24 有遇见检测不到的情况，所以将负载检测值调低
// #define MIN_LOAD_ADC_VAL            480//(1000)     // 2024 11 01 有遇见检测不到的情况，所以将负载检测值调低

#define MIN_LOAD_ADC_VAL            350 // 2024 11 29 斩脂刀时，容易检测不到
//**********************根据接触面积**********************
#define HF_OUTPUT_DEC2_ADC_VAL    700   // 如果adc_val 小于该值，则输出降低至 70%
#define HF_OUTPUT_DEC1_ADC_VAL    800   // 如果adc_val 小于该值，则输出降低 至 80%
//********************************************************
//

#define MIN_SHORT_ADC_VAL       (1900)

#define QUIT_SHORT_CIRCLE_CNT    (25)
#define NORMAL_LOAD_ACTIVE_CNT   (5)
/***************************************/

#define HF_WAVE_WORK_TIME       (1000)
#define EMS_WAVE_WORK_TIME      (2000)
#define ONE_CYCLE_TIME          (HF_WAVE_WORK_TIME + EMS_WAVE_WORK_TIME)


//#define FACE_MODE_HF_TIME      (200)// (200)  //20241015 改为500ms    
// #define FACE_MODE_HF_TIME       (400) //(200)--20241017 前四档模式都改为第四档时间 4*30 = 120    并且前四档不变
// #define FACE_MODE_HF_TIME       (800) //(200)--20241023 前四档模式都改为第四档时间 4*30 = 120    并且前四档不变
#define FACE_MODE_HF_TIME       (650) //2024 11 04 高周波时间从 800 --->650
#define FACE_MODE_EMS_TIME      (600)

// #define BODY_MODE_HF_TIME      (800)//(300)
#define BODY_MODE_HF_TIME      (350) //2024 11 04 高周波时间从 800 --->650

#define BODY_MODE_EMS_TIME     (800)

#define HAIR_MODE_HF_TIME      (0)//(300) 2024 10 18 号 头皮模式取消高周波
#define HAIR_MODE_EMS_TIME     (1000)

#define MAX_MODE_HF_TIME       (0)
#define MAX_MODE_EMS_TIME      (2000)//(2000)

#define NEW_FACE_MODE_HF_TIME       (0)
#define NEW_FACE_EMS_TIME      (505)//(2000)

/*********佩戴头adc检测************************/
// 无佩戴头时，硬件上有上拉电阻，将电压抬高到3v左右

#define WEAR_OFFLINE_MIN_ADC            (3800)
#define WEAR_MIDDLE_MODULE_MAX_ADC      (2400)
#define WEAR_LITTLE_MODULE_MAX_ADC      (1200)
/*********佩戴头adc检测 end*********************/

#define LOAD_ADC_CNT            (10)


#define GSENSOR_CONTINUE_HF_TIME  (15000)   // 一次gsensor 持续15秒


int load_adc_array[LOAD_ADC_CNT] ={0};
static uint8_t debug_printf_delay;

typedef struct 
{
    int HF_continue_time;
    int HF_duty;
    int HF_period;
    int one_cycle_run_cnt;
    int one_cycle_period;   // 一整个波形时间
    int ems_wave_percent;
    int ems_wave_dec_flag;
    int motor_alarm_flag;
    int repeat_cnt;

    int last_gsensor_sta;
    int gsensor_move_deshaking_cnt;
    int gsensor_static_deshaking_cnt;

    uint16_t hf_load_adc;
    uint16_t hf_vcc_adc;

    /* data */
}OUTPUT_WAVE_t;

OUTPUT_WAVE_t output_wave_data;


typedef void(*ems_freq_fun_t)(EMS_DUTY_LEVEL_e);
typedef struct 
{
    uint8_t freq;
    ems_freq_fun_t func;

    /* data */
}EMS_FREQ_FUNC_t;


EMS_FREQ_FUNC_t ems_freq_fun_item[]={
    {EMS_100HZ_FREQ , ems_freq_select_100hz},
    {EMS_500HZ_FREQ , ems_freq_select_500hz},
    {EMS_1KHZ_FREQ , ems_freq_select_1khz},
    {EMS_2KHZ_FREQ , ems_freq_select_2khz},
    {EMS_3KHZ_FREQ , ems_freq_select_3khz},
    {EMS_4KHZ_FREQ , ems_freq_select_4khz},
    {EMS_9KHZ_FREQ , ems_freq_select_9khz},
    {EMS_12KHZ_FREQ , ems_freq_select_12khz},
    {EMS_15KHZ_FREQ , ems_freq_select_15khz},

};


//************冒泡排序法 */
void Bubble_Sort(int *arr, int size)  
{  
    int i, j, tmp;  
    int swap_times = 0;
    
    for (i = 0; i < size - 1; i++) {  
        for (j = 0; j < size - i - 1; j++) {  
            if (arr[j] > arr[j+1]) {  
                tmp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = tmp; 
                swap_times ++; 
            }
        }  
    }  
    // printf(" \r\n bubble_sort_02 swap_times:%d \r\n", swap_times);
} 



//========================================================================
// 函数: int get_load_adc (void)
// 描述: ，负载检测adc 的值
// 参数: none.
// 返回: none.
// 版本: V1.0, 2020-09-15
//========================================================================
int get_load_adc(void)
{
    return output_wave_data.hf_load_adc;
}


//========================================================================
// 函数: void load_active_check (void)
// 描述: RF作为检波信号时，负载检测
// 参数: none.
// 返回: none.
// 版本: V1.0, 2020-09-15
//========================================================================
static void load_active_check(int adc_val)
{
    static int cnt = 0;

    static int active_cnt = 0;
    static int short_circle_cnt = 0;
    static int offline_cnt = 0;
    int tmp_cnt;

    load_adc_array[cnt] = adc_val;
    cnt ++;
    if(LOAD_ADC_CNT == cnt){
        cnt = 0;
        Bubble_Sort(load_adc_array, LOAD_ADC_CNT);

        // 短路
        if(load_adc_array[LOAD_ADC_CNT/2] > MIN_SHORT_ADC_VAL){
            short_circle_cnt ++;
            if(short_circle_cnt > 10){
                // printf("load_adc[%d],sys short_circle \r\n", load_adc_array[LOAD_ADC_CNT/2]);
                set_sys_load_state(SHORT_CIRCLE_STA);
            }
            active_cnt = 0;
            offline_cnt = 0;
        }
        // 带载
        else if(load_adc_array[LOAD_ADC_CNT/2] > MIN_LOAD_ADC_VAL){
            active_cnt ++;
            
            // 如果上次时短路状态，则要多判断几次才进入正常的输出，防止出现频繁跳动情况
            if(SHORT_CIRCLE_STA == get_sys_load_state()){
                tmp_cnt = QUIT_SHORT_CIRCLE_CNT;
            }
            else{
                tmp_cnt = NORMAL_LOAD_ACTIVE_CNT;
            }

            if(active_cnt > tmp_cnt){
                active_cnt = 0;
                // printf("load_adc[%d], sys active_line \r\n", load_adc_array[LOAD_ADC_CNT/2]);
                set_sys_load_state(ON_LINE_STA);
                sys_data.cur_mode_active_online_flag = 1; 
                short_circle_cnt = 0;
                offline_cnt = 0;
            }  
        }
        // 空载
        else{
            offline_cnt ++;

            if(offline_cnt > 5){
                short_circle_cnt = 0;
                active_cnt = 0;
            }
            if(offline_cnt > 6){
                set_sys_load_state(OFF_LINE_STA);
            }
        }

        output_wave_data.hf_load_adc = load_adc_array[LOAD_ADC_CNT/2];

        // set_sys_load_state(ON_LINE_STA);// debug
    }
}

//========================================================================
// 函数: void ems_load_check (void)
// 描述: RF作为检波信号时，负载检测
// 参数: none.
// 返回: none.
// 版本: V1.0, 2020-09-15
//========================================================================
static void ems_load_check(void)
{
    static int online_cnt, offline_cnt;

    if(IS_EMS_LOAD_ACTIVE()){
        online_cnt ++;
        if(online_cnt > 10){
            offline_cnt = 0;
            set_sys_load_state(ON_LINE_STA);
            //  printf(" \r\n ems_det_online ======== \r\n");
        }
    }
    else{
        offline_cnt ++;
        if(offline_cnt > 10){
            online_cnt = 0;
            set_sys_load_state(OFF_LINE_STA);
            //  printf(" \r\n ems_det_offline------ \r\n");
        }
    }
}

//========================================================================
// 函数: void 佩戴头检测 (void)
// 描述: 
// 参数: none.
// 返回: none.
// 版本: V1.0, 2020-09-15
//========================================================================
static void wear_mode_active_check(int adc_val)
{
    static int cnt = 0;

    static int middle_moudle_active_cnt = 0;
    static int little_module_active_cnt = 0;
    static int offline_cnt = 0;
    int tmp_cnt;

    load_adc_array[cnt] = adc_val;
    cnt ++;
    if(LOAD_ADC_CNT == cnt){
        cnt = 0;
        Bubble_Sort(load_adc_array, LOAD_ADC_CNT);

        // 离线
        if(load_adc_array[LOAD_ADC_CNT/2] > WEAR_OFFLINE_MIN_ADC){

            offline_cnt ++;

            if(offline_cnt > 5){
                little_module_active_cnt = 0;
                middle_moudle_active_cnt = 0;
            }
            if(offline_cnt > 6){
                set_wear_module_state(WEAR_OFFLINE_MODULE);
            }
        }
        // 马达
        else if(load_adc_array[LOAD_ADC_CNT/2] > WEAR_MIDDLE_MODULE_MAX_ADC){
           middle_moudle_active_cnt ++;
           if(middle_moudle_active_cnt > 5){
                offline_cnt = 0;
                little_module_active_cnt = 0;
                set_wear_module_state(WEAR_MOTOR_MODULE);
           }
        }
        // 电磁铁
        else if(load_adc_array[LOAD_ADC_CNT/2] > WEAR_LITTLE_MODULE_MAX_ADC){
            little_module_active_cnt ++;
            if(middle_moudle_active_cnt > 5){
                offline_cnt = 0;
                middle_moudle_active_cnt = 0;
                set_wear_module_state(WEAR_FE_MODULE);
           }
        }

        output_wave_data.hf_load_adc = load_adc_array[LOAD_ADC_CNT/2];
    }
}


/****************************************************************
 * 
 * 
    固定的vcc
 * 
 * **************************************************************/
void ems_one_freq_const_vcc(uint8_t ems_freq)
{
    uint8_t index;
    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;

    if(output_wave_data.one_cycle_run_cnt == 1){
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();
    }

    if(output_wave_data.one_cycle_run_cnt == 10 ){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        ems_output_disable();
        
        // ems_freq_select===============
        for(index = 0; index < sizeof(ems_freq_fun_item)/sizeof(ems_freq_fun_item[0]); index++){
            if(ems_freq == ems_freq_fun_item[index].freq){
                ems_freq_fun_item[index].func(EMS_DEFAULT_DUTY);
                break;
            }
        }
        ems_output_enable(); 
        ems_voltage_percent_select(100);  
        ems_power_on(); 
        //    printf("\n\r hair_wave_restart  \n\r");  
    }   // 开始变频 + 变压
   
    if(output_wave_data.one_cycle_run_cnt > HAIR_MODE_EMS_TIME + HAIR_MODE_HF_TIME + (30 * get_sys_level())){
        output_wave_data.one_cycle_run_cnt  = 0;
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
    }
}


/****************************************************************
 * 
 * 
    固定的vcc
 * 
 ********************************************************/
void ems_freq_const_vcc_select(uint8_t ems_freq)
{
    int index;

    hf_power_off();
    my_hf_wave_stop();
    hf_output_disable();
    ems_output_disable();  

    // ems_freq_select =============
    for(index = 0; index < sizeof(ems_freq_fun_item)/sizeof(ems_freq_fun_item[0]); index++){
        if(ems_freq == ems_freq_fun_item[index].freq){
            ems_freq_fun_item[index].func(EMS_DEFAULT_DUTY);
            break;
        }
    }
    ems_output_enable(); 
    ems_voltage_percent_select(100);  
    ems_power_on(); 
        //    printf("\n\r hair_wave_restart  \n\r");  
}

/*******************************************************************
 * 
 * 
    纯EMS输出
 * 
 *******************************************************/
void only_ems_wave_test(uint8_t ems_freq)
{
    int index;

    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;

    //ems 开始
    if(output_wave_data.one_cycle_run_cnt == 1){
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();
    }

    if(output_wave_data.one_cycle_run_cnt == 10 ){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        ems_output_disable(); 
        ems_power_off();

        // ems_freq_select ====================
        for(index = 0; index < sizeof(ems_freq_fun_item)/sizeof(ems_freq_fun_item[0]); index++){
            if(ems_freq == ems_freq_fun_item[index].freq){
                ems_freq_fun_item[index].func(EMS_DEFAULT_DUTY);
                break;
            }
        }

        ems_output_enable(); 
        ems_power_on();
        ems_voltage_percent_select(10);   
        //    printf("\n\r hair_wave_restart  \n\r");  
    }   // 开始变频 + 变压
    else if(output_wave_data.one_cycle_run_cnt > HAIR_MODE_HF_TIME  + (10 * get_sys_level()) + 5){
        // 变压函数
        if(output_wave_data.one_cycle_run_cnt%10 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
            if(output_wave_data.ems_wave_dec_flag){
                if(output_wave_data.ems_wave_percent > 60){   
                        output_wave_data.ems_wave_percent -= 10;
                }
                else if(output_wave_data.ems_wave_percent > 30){   
                        output_wave_data.ems_wave_percent -= 8;
                }
                else if(output_wave_data.ems_wave_percent > 10){
                    output_wave_data.ems_wave_percent -= 2;
                }
                else{
                    output_wave_data.ems_wave_dec_flag = 0;
                    hight_vol_hold_time = 0;
                }
            }
            else{
                
                if(output_wave_data.ems_wave_percent >= 100){
                    output_wave_data.ems_wave_percent = 100;
                    hight_vol_hold_time ++;
                    if(hight_vol_hold_time >= 15){ 
                        output_wave_data.ems_wave_dec_flag = 1;
                    }
                }
                else{       // 上升阶段 总耗时 大约300ms
                    if(output_wave_data.ems_wave_percent < 30){
                        output_wave_data.ems_wave_percent += 2;
                    }
                    else if(output_wave_data.ems_wave_percent < 60){
                            output_wave_data.ems_wave_percent += 8;
                    }
                    else if(output_wave_data.ems_wave_percent < 100){
                            output_wave_data.ems_wave_percent += 10;
                    }
                }
            }
            // output_wave_data.ems_wave_percent ++;   
            ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
        }
    }
    if(output_wave_data.one_cycle_run_cnt > HAIR_MODE_EMS_TIME + HAIR_MODE_HF_TIME + (30 * get_sys_level())){
        output_wave_data.one_cycle_run_cnt  = 0;
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
    }
}

/************************************
 *    纯RF输出   1MHZ
 * 
 ************************************/

void only_RF_wave_test(void)
{
    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;

    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    if((OFF_LINE_STA == get_sys_load_state())||(SHORT_CIRCLE_STA == get_sys_load_state())){
        if(output_wave_data.one_cycle_run_cnt%100 == 0){
            ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            hf_power_on();
            my_hf_wave_start(HF_FREQ_1_5MHZ);
            hf_output_enable();
        }
        else if((output_wave_data.one_cycle_run_cnt%100 > 3)&&(output_wave_data.one_cycle_run_cnt%100 < 10)){
            load_active_check(my_HF_load_adc_read());
        }
        else if(output_wave_data.one_cycle_run_cnt%100 == 10){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();
        }
        last_load = 0;
        return;
    }

    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            motor_shor_on();
        } 
    }
    // 高周波 负载在线时
    if(output_wave_data.one_cycle_run_cnt < HF_WAVE_WORK_TIME + (10 * get_sys_level() < HF_WAVE_WORK_TIME? 10 * get_sys_level(): HAIR_MODE_HF_TIME)){
        if(output_wave_data.one_cycle_run_cnt == 1){
            ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            hf_power_on();
            if(sys_data.cur_mode_run_cnt < HF_USE_2MHZ_CNT){
                my_hf_wave_start(HF_FREQ_2_0MHZ);
            }
            else{
                my_hf_wave_start(HF_FREQ_1_5MHZ);
            }
            
            hf_output_enable();
        }
        if((output_wave_data.one_cycle_run_cnt > 5) && (0 == output_wave_data.one_cycle_run_cnt%2)){

            load_active_check(my_HF_load_adc_read());
            
        }

    } // 高周波停止
    else if(output_wave_data.one_cycle_run_cnt == HF_WAVE_WORK_TIME + (10 * get_sys_level())){
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();
    } 

    if(output_wave_data.one_cycle_run_cnt > HF_WAVE_WORK_TIME + HF_WAVE_WORK_TIME + (30 * get_sys_level())){
        output_wave_data.one_cycle_run_cnt  = 0;
    }

}




/**************************************************************
   ems 波形 模拟正选波 
 * 
 ***********************************************************/
__STATIC_INLINE void ems_simulate_sine_wave(void)
{
    static uint8_t hight_vol_hold_time = 0; 

    if(output_wave_data.ems_wave_dec_flag){
        if(output_wave_data.ems_wave_percent > 60){   
            output_wave_data.ems_wave_percent -= 3;
        }
        else if(output_wave_data.ems_wave_percent > 30){   
            output_wave_data.ems_wave_percent -= 3;
        }
        else if(output_wave_data.ems_wave_percent > 10){
            output_wave_data.ems_wave_percent -= 3;
        }
        else{
            output_wave_data.ems_wave_dec_flag = 0;
            output_wave_data.ems_wave_percent = 0;
            hight_vol_hold_time = 0;
            // printf("\n\r ems_simulate_sine_wave restart  \n\r");
        }
    }
    else{
        
        if(output_wave_data.ems_wave_percent >= 100){
            output_wave_data.ems_wave_percent = 100;
            hight_vol_hold_time ++;
            if(hight_vol_hold_time >= 30){ 
                output_wave_data.ems_wave_dec_flag = 1;
                //   printf("\n\r ems_simulate_sine_wave wave begin dec  \n\r");
            }
        }
        else{       // 上升阶段 总耗时 大约300ms
            if(output_wave_data.ems_wave_percent < 30){
                output_wave_data.ems_wave_percent += 3;
            }
            else if(output_wave_data.ems_wave_percent < 60){
                    output_wave_data.ems_wave_percent += 3;
            }
            else if(output_wave_data.ems_wave_percent < 100){
                    output_wave_data.ems_wave_percent += 3;
            }
        }
    }
    // output_wave_data.ems_wave_percent ++;   
    ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
}

/**************
   ems 波形 模拟锯齿波
 * 
 * **/
 __STATIC_INLINE void ems_simulate_slope_wave(void)
{
    static uint8_t hight_vol_hold_time = 0; 

    if(output_wave_data.ems_wave_dec_flag){
        // if(output_wave_data.ems_wave_percent > 60){   
        //         output_wave_data.ems_wave_percent -= 3;
        // }
        // else if(output_wave_data.ems_wave_percent > 30){   
        //         output_wave_data.ems_wave_percent -= 5;
        // }
        // else if(output_wave_data.ems_wave_percent > 10){
        //     output_wave_data.ems_wave_percent -= 10;
        // }
        // else{
            output_wave_data.ems_wave_percent = 0;
            output_wave_data.ems_wave_dec_flag = 0;
            hight_vol_hold_time = 0;
        // }
    }
    else{
        
        if(output_wave_data.ems_wave_percent >= 100){
            output_wave_data.ems_wave_percent = 100;
            hight_vol_hold_time ++;
            if(hight_vol_hold_time >= 10){ 
                output_wave_data.ems_wave_dec_flag = 1;
            }
        }
        else{       // 上升阶段 总耗时 大约300ms
            // if(output_wave_data.ems_wave_percent < 30){
            //     output_wave_data.ems_wave_percent += 10;
            // }
            // else if(output_wave_data.ems_wave_percent < 60){
            //         output_wave_data.ems_wave_percent += 5;
            // }
            // else if(output_wave_data.ems_wave_percent < 100){
            //         output_wave_data.ems_wave_percent += 3;
            // }
            output_wave_data.ems_wave_percent += 3;
        }
    }
    // output_wave_data.ems_wave_percent ++;   
    ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
}

/*********************************************************************************************************
*   定时检测HF,每100ms检测一次
*
*
*       
*******************************************************************/
int hf_check_load_preiod(void)
{
    if(output_wave_data.one_cycle_run_cnt%100 == 0){
        ems_power_off();
        ems_playlod1_stop();
        ems_output_disable();
        hf_power_on();
        my_hf_wave_start(HF_FREQ_1_5MHZ);
        hf_output_enable();
        set_sys_hf_flag(1);
    }
    else if((output_wave_data.one_cycle_run_cnt%100 > 3)&&(output_wave_data.one_cycle_run_cnt%100 < 15)){
        load_active_check(my_HF_load_adc_read());

        if(output_wave_data.one_cycle_run_cnt%100 == 5){
            //  printf("rf_check_load_adc[%d],  \r\n", my_HF_load_adc_read());
        }
    }
    else if(output_wave_data.one_cycle_run_cnt%100 == 15){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        
    }
    return 0;
}


/*********************************************************************************************************
*   高周波输出控制ctrl
*
*
*       
*******************************************************************/
int hf_output_ctrl(void)
{
    if(output_wave_data.one_cycle_run_cnt == 1){
        ems_power_off();
        ems_playlod1_stop();
        ems_output_disable();
        hf_power_on();
        if(sys_data.cur_mode_run_cnt < HF_USE_2MHZ_CNT){
            my_hf_wave_start(HF_FREQ_2_0MHZ);
        }
        else{
            my_hf_wave_start(HF_FREQ_1_5MHZ);
        }
        hf_output_enable();
        set_sys_hf_flag(1);
    }
#if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)        
   // 如果负载 在线时，
    if(ON_LINE_STA == get_sys_load_state()){
        if((output_wave_data.one_cycle_run_cnt > 5) &&(output_wave_data.one_cycle_run_cnt < 100) && (0 == output_wave_data.one_cycle_run_cnt%2)){
            // output_wave_data.hf_load_adc = my_HF_load_adc_read();
            // output_wave_data.hf_vcc_adc = my_HF_vcc_adc_read();
            load_active_check(my_HF_load_adc_read());
        }

        if(output_wave_data.one_cycle_run_cnt == 25){
            // printf("hf_stop_00  ---\r\n");
        }
        set_sys_hf_flag(1);
    }
    else{
    // 负载离线时
        if(output_wave_data.one_cycle_run_cnt%100 == 0){
            ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            hf_power_on();
            my_hf_wave_start(HF_FREQ_1_5MHZ);
            hf_output_enable();
            set_sys_hf_flag(1);
        }


        if((output_wave_data.one_cycle_run_cnt%100 > 5) && (output_wave_data.one_cycle_run_cnt%100 < 25) && (output_wave_data.one_cycle_run_cnt%2)){
            
            load_active_check(my_HF_load_adc_read());
        }
        if(output_wave_data.one_cycle_run_cnt%100 == 25){
            // printf("hf_stop_111111  ---\r\n");
            hf_power_off();
            hf_output_disable();
            my_hf_wave_stop();
            // printf("hf_stop_2  ---\r\n");
        }
    }

#endif


    return 0;
}

/**************
*   level ctrl ems duty
*   根据档位调节ems的占空比，防止档位大+占空比大，出现脸疼的现象
 * 
 * **/
 __STATIC_INLINE EMS_DUTY_LEVEL_e level_ctrl_ems_duty(void)
 {
    EMS_DUTY_LEVEL_e cur_ems_duty;

    switch(get_sys_level())
    {
        case 1:
        case 2:
        case 3:
        case 4:{
            cur_ems_duty = EMS_LARGE_DUTY;
            break;
        }
        case 5:
        case 6:
        case 7:{
            cur_ems_duty = EMS_MIDDLE_DUTY;
            break;
        }
        case 8:
        case 9:
        case 10:{
            cur_ems_duty = EMS_LITTLE_DUTY;
            break;
        }
        default:{
            cur_ems_duty = EMS_LITTLE_DUTY;
            break;
        }
    }
    return cur_ems_duty;
 }


/*********************************************************************************************************
   Ⅱ.FACE 脸部模式   EMS（中频电流麻感）+电穿孔+高周波——适用全脸

    2024 10 22 修改逻辑，如果是运行过程中 负载离线了，则停止HF输出，EMS保持不变
 *       
 *******************************************************************/
static void face_mode_waves(void)
{

    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;
    static uint8_t cur_ems_wave;
    int max_rf_time;
    EMS_DUTY_LEVEL_e cur_ems_duty;

    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

  // 2024 10 22 修改逻辑，如果是运行过程中 负载离线了，则停止HF输出，EMS保持不变
    if((OFF_LINE_STA == get_sys_load_state()) && (0 == sys_data.cur_mode_active_online_flag)){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

    //前四档，时间固定
    if(get_sys_level()>4){
        max_rf_time = FACE_MODE_HF_TIME+ 100;
    }
    else{
        max_rf_time = FACE_MODE_HF_TIME;
    }

    // 根据 运行时间再调整
    if(max_rf_time > 550){ 
        if(sys_data.cur_mode_run_cnt < 60){
            max_rf_time += 300;
        }

        if(sys_data.cur_mode_run_cnt > 60*4){
            // max_rf_time -= 500;
            max_rf_time -= 550;
        }
        else if(sys_data.cur_mode_run_cnt > 60*3){
            // max_rf_time -= 400;
            max_rf_time -= 450;
        }
        else if(sys_data.cur_mode_run_cnt > 60*2){
            max_rf_time -= 150;
        }
    }

    // 根据负载情况再次调整输出
    if(get_load_adc() < HF_OUTPUT_DEC2_ADC_VAL){
        max_rf_time = max_rf_time*50/100;
    }
    else if(get_load_adc() < HF_OUTPUT_DEC1_ADC_VAL){
        max_rf_time = max_rf_time*60/100;
    }
    //-----------------------

    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                output_wave_data.motor_alarm_flag = 1;
                // buzzer_on_with_param(3, 5, 2);
                output_wave_data.HF_continue_time = 0;
                output_wave_data.last_gsensor_sta = 0;
            }
            // motor_shor_on();
            //前四档，时间固定
            output_wave_data.one_cycle_run_cnt = max_rf_time;
        } 
    }


#ifdef USE_GSENSER_CTRL
    if(ALIGN_STA != get_sys_state()){
        if(output_wave_data.HF_continue_time){
            
            output_wave_data.HF_continue_time --;
            // 运行时间到达，换区提醒
            if(output_wave_data.HF_continue_time == 0){
                // buzzer_on_with_param(3, 5, 1);
            }
            // 如果gsensor 移动，则停止输出
            if((get_gsensor_flag()&&(output_wave_data.HF_continue_time < GSENSOR_CONTINUE_HF_TIME - 2000))){
                output_wave_data.HF_continue_time = 0;
            }
            else{
                output_wave_data.gsensor_move_deshaking_cnt = 0;
            }

            if(output_wave_data.HF_continue_time == 0){
                output_wave_data.last_gsensor_sta = 0;
            }
        }
        else{
            if(get_gsensor_flag()){
                // 跳过rf输出
                output_wave_data.gsensor_move_deshaking_cnt = 0;
        
                output_wave_data.last_gsensor_sta = 1;
                output_wave_data.gsensor_static_deshaking_cnt = 0;
            }
            else{   
                if(output_wave_data.last_gsensor_sta){
                    output_wave_data.gsensor_static_deshaking_cnt ++;
                    if(output_wave_data.gsensor_static_deshaking_cnt > 800){
                        // buzzer_on_with_param(3, 5, 3);
                        output_wave_data.HF_continue_time = GSENSOR_CONTINUE_HF_TIME;
                        output_wave_data.last_gsensor_sta = 0;
                    }
                }
            }
            // 不再输出 高周波
            if(output_wave_data.one_cycle_run_cnt < max_rf_time){
                output_wave_data.one_cycle_run_cnt = max_rf_time;
            }
        }
    }
    else{
        if(max_rf_time > 100){
            max_rf_time = 100;
        }
    }

#endif
    // 高周波 负载在线时
    // if(output_wave_data.one_cycle_run_cnt < FACE_MODE_HF_TIME + (30 * get_sys_level() < FACE_MODE_HF_TIME? 30 * get_sys_level(): FACE_MODE_HF_TIME))
    if(output_wave_data.one_cycle_run_cnt < max_rf_time)
    {
        hf_output_ctrl();
    } // 高周波停止
   
    else if(output_wave_data.one_cycle_run_cnt == max_rf_time){
        ems_output_disable();
        ems_output_disable();

        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();
        // printf("hf_stop_2  ---\r\n");
    }  
    else{ //ems 开始
        if(output_wave_data.one_cycle_run_cnt == max_rf_time + 5){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();

            ems_output_disable();
            ems_power_off();
            

            cur_ems_duty = level_ctrl_ems_duty();
            // ems_freq_select_12khz(cur_ems_duty);

            ems_freq_select_3khz(cur_ems_duty);
            ems_output_enable();     
            ems_voltage_percent_select(10); 
            ems_power_on();
            cur_ems_wave ++;
            //  printf("ems_start  ---\r\n");
            //  
        }   // 开始变频 + 变压
        else if(output_wave_data.one_cycle_run_cnt > max_rf_time+ 5){
            // 变压函数
            if(output_wave_data.one_cycle_run_cnt%5 == 0){ // 10ms减去一次
                
                ems_output_disable();
                ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                if(0 == cur_ems_wave%2){
                    ems_simulate_sine_wave();
                }
                else{
                    ems_simulate_slope_wave();
                }

                ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
                if(output_wave_data.ems_wave_percent > 50){
                    // ems_load_check();
                }
                ems_output_enable();  
                
            }
            // 可以读取电压标志
            if(output_wave_data.one_cycle_run_cnt == max_rf_time + FACE_MODE_EMS_TIME - 200){
                set_sys_hf_flag(0);
            }


        }
        if(output_wave_data.one_cycle_run_cnt > max_rf_time + FACE_MODE_EMS_TIME){
            output_wave_data.one_cycle_run_cnt  = 0;
            output_wave_data.ems_wave_percent = 0;
            set_sys_hf_flag(0);
        }
        // }
   }

}

/**********************************************************************************************************************
   Ⅲ.BODY 身体模式   EMS（变压多频的拍打体感）+高周波+vcsel红灯660nm+绿光540nm——适用身体
 ***********************************************************************************************************/


static void body_mode_waves(void)
{
    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    static uint8_t last_load;
    int max_rf_time;
    EMS_DUTY_LEVEL_e cur_ems_duty;

    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

  // 2024 10 22 修改逻辑，如果是运行过程中 负载离线了，则停止HF输出，EMS保持不变
    if((OFF_LINE_STA == get_sys_load_state()) && (0 == sys_data.cur_mode_active_online_flag)){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

    //前四档，时间固定
    if(get_sys_level()>4){
        max_rf_time = BODY_MODE_HF_TIME+ 100;
    }
    else{
        max_rf_time = BODY_MODE_HF_TIME;
    }

        // 根据 运行时间再调整

    if(max_rf_time > 550){    
        if(sys_data.cur_mode_run_cnt < 60){
            max_rf_time += 1000;
        }

        if(sys_data.cur_mode_run_cnt > 60*4){
            // max_rf_time -= 500;
            max_rf_time -= 550;
        }
        else if(sys_data.cur_mode_run_cnt > 60*3){
            // max_rf_time -= 400;
            max_rf_time -= 450;
        }
        else if(sys_data.cur_mode_run_cnt > 60+60){
            max_rf_time -= 150;
        }
    }

    // 根据负载情况再次调整输出
    if(get_load_adc() < HF_OUTPUT_DEC2_ADC_VAL){
        max_rf_time = max_rf_time*50/100;
    }
    else if(get_load_adc() < HF_OUTPUT_DEC1_ADC_VAL){
        max_rf_time = max_rf_time*60/100;
    }
    //-------调整完毕


    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                // buzzer_on_with_param(3, 5, 2);
                output_wave_data.motor_alarm_flag = 1;
                output_wave_data.HF_continue_time = 0;
            }
            // output_wave_data.one_cycle_run_cnt = BODY_MODE_HF_TIME + (30 * get_sys_level());
            output_wave_data.one_cycle_run_cnt = max_rf_time;
        } 
    }
   
#ifdef USE_GSENSER_CTRL
    if(ALIGN_STA != get_sys_state()){
        if(OFF_LINE == get_zhan_zhi_dao_state()){   // 佩戴斩脂刀时，不再受陀螺仪控制
            if(output_wave_data.HF_continue_time){
                output_wave_data.HF_continue_time --;

                // 运行时间到达，换区提醒
                if(output_wave_data.HF_continue_time == 0){
                    // buzzer_on_with_param(3, 5, 1);
                }
                    // 如果gsensor 移动，则停止输出
                if(((get_gsensor_flag())&&(output_wave_data.HF_continue_time < GSENSOR_CONTINUE_HF_TIME - 2000))){
                output_wave_data.HF_continue_time = 0;
                }
                else if(output_wave_data.HF_continue_time == 0){
                    output_wave_data.last_gsensor_sta = 0;
                }
            }
            else{
                if(get_gsensor_flag()){
                    // 跳过rf输出
                    output_wave_data.gsensor_move_deshaking_cnt = 0;
                    output_wave_data.last_gsensor_sta = 1;
                    output_wave_data.gsensor_static_deshaking_cnt = 0;
                }
                else{   
                    if(output_wave_data.last_gsensor_sta){
                        output_wave_data.gsensor_static_deshaking_cnt ++;
                        if(output_wave_data.gsensor_static_deshaking_cnt > 800){
                            // buzzer_on_with_param(3, 5, 3);
                            output_wave_data.HF_continue_time = GSENSOR_CONTINUE_HF_TIME;
                            output_wave_data.last_gsensor_sta = 0;
                        }
                    }
                }
                // 暂停高周波输出
                if((output_wave_data.one_cycle_run_cnt < max_rf_time)){
                    output_wave_data.one_cycle_run_cnt = max_rf_time;
                }
            }
        }
    }
    else{
        if(max_rf_time > 100){
            max_rf_time = 100;
        }
    }
#endif


    // // 高周波 负载在线时
    // if(output_wave_data.one_cycle_run_cnt < BODY_MODE_HF_TIME + (30 * get_sys_level() < BODY_MODE_HF_TIME? 30 * get_sys_level(): FACE_MODE_HF_TIME)){
    if(output_wave_data.one_cycle_run_cnt < max_rf_time)
    {  
       hf_output_ctrl(); 

    } // 高周波停止
   
    // else if(output_wave_data.one_cycle_run_cnt == BODY_MODE_HF_TIME + (30 * get_sys_level())){
    else if(output_wave_data.one_cycle_run_cnt == max_rf_time){    
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();
    }  
    else{ //ems 开始
        if(output_wave_data.one_cycle_run_cnt == max_rf_time + 5){
            
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();
            ems_output_disable();
            ems_power_off();
            
            
            cur_ems_duty = level_ctrl_ems_duty();
            // ems_freq_select_3khz(cur_ems_duty);
            ems_playlod1_restar();
            
            ems_output_enable();    
            output_wave_data.ems_wave_percent = 30; 
            ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
            ems_power_on();  
            // ems_voltage_percent_select(100);   
            printf("\n\r  ems_start_per:100  \n\r");
        }
        else if(output_wave_data.one_cycle_run_cnt > max_rf_time + 5){
            if(output_wave_data.one_cycle_run_cnt%8 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                // if(output_wave_data.ems_wave_percent < 100){
                    // ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                    // output_wave_data.ems_wave_percent++;
                    ems_simulate_sine_wave();
                    // ems_voltage_percent_select(output_wave_data.ems_wave_percent);
                // }
            }

            if(output_wave_data.one_cycle_run_cnt == max_rf_time + MAX_MODE_EMS_TIME - 200){
                set_sys_hf_flag(0);
            }

        }

        if(output_wave_data.one_cycle_run_cnt > max_rf_time + MAX_MODE_EMS_TIME){
            printf("\n\r  body_one_cycle:[%d]  \n\r", output_wave_data.one_cycle_run_cnt);
            output_wave_data.one_cycle_run_cnt  = 0;
            // motor_fe_start();
        }
    }
}

/**************
 * 
 * 
    Ⅳ.HAIR 头皮模式   EMS（变频变压的抓感体感）+高周波+vcsel红灯660nm——适用头皮
 * 
 * **/
static void hair_mode_waves(void)    // hair_mode_waves  max_mode_waves
{
    static uint8_t last_load;
    static uint8_t cur_ems_wave;
    static uint8_t cur_ems_freq;
    static uint8_t check_ems_freq_flag;
    EMS_DUTY_LEVEL_e cur_ems_duty;
    

  if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        ems_output_disable();
        return;
    }

    ems_power_on(); 
    if(OFF_LINE_STA == get_sys_load_state()){
        if(output_wave_data.one_cycle_run_cnt%50==0){
            my_hf_wave_stop();
            hf_output_disable();

            if(ON_LINE == get_zhan_zhi_dao_state()){
                ems_freq_select_4khz(EMS_LITTLE_DUTY);
            }
            else{
                cur_ems_duty = level_ctrl_ems_duty();
                ems_freq_select_1khz(cur_ems_duty);
            }
            ems_output_enable();   
            ems_power_on();  
            ems_voltage_percent_select(100);
            // set_sys_hf_flag(0);
            // printf(" \r\n ems_det_offline 111==== \r\n");
        }

        if(output_wave_data.one_cycle_run_cnt%50 < 5){
            ems_load_check();
        }

        if(output_wave_data.one_cycle_run_cnt%50 == 5){
            ems_playlod1_stop();
            ems_output_disable();  
        }
        last_load = 0;

        // set_sys_load_state(ON_LINE_STA); // debug
        return;   
    }

    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                output_wave_data.motor_alarm_flag = 1;
            }
            // printf(" \r\n ems_det_online ======== \r\n");
        }
        else{
            //  printf(" \r\n ems_det_offline ======== \r\n");
        } 
    }

    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        if((output_wave_data.one_cycle_run_cnt) < 100){

            if(output_wave_data.one_cycle_run_cnt == 80){
                my_hf_wave_stop();
                hf_output_disable();

                if(ON_LINE == get_zhan_zhi_dao_state()){
                    ems_freq_select_4khz(EMS_LITTLE_DUTY);
                }
                else{
                    cur_ems_duty = level_ctrl_ems_duty();
                    ems_freq_select_1khz(cur_ems_duty);
                }
                ems_output_enable();   
                ems_power_on();  
                ems_voltage_percent_select(100);
                // set_sys_hf_flag(0);
                // printf(" \r\n ems_det_offline 111==== \r\n");
            }

            if((output_wave_data.one_cycle_run_cnt > 80)&&(output_wave_data.one_cycle_run_cnt < 95)){
                ems_load_check();
            }

            if(output_wave_data.one_cycle_run_cnt == 95){
                ems_playlod1_stop();
                ems_output_disable();  
            }
            return;
        }
    #endif

    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        // if((output_wave_data.one_cycle_run_cnt % HAIR_MODE_EMS_TIME) == 5){
        if((output_wave_data.one_cycle_run_cnt) == 200){
    #else
        if((output_wave_data.one_cycle_run_cnt % HAIR_MODE_EMS_TIME) == 5){
    #endif
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        ems_output_disable();

        ems_power_off();
        cur_ems_freq ++;
        cur_ems_wave ++;   

        cur_ems_duty = level_ctrl_ems_duty();

        ems_freq_select_2khz(cur_ems_duty);
        ems_playlod1_restar();
        ems_output_enable();
        ems_power_on();  
        output_wave_data.ems_wave_percent = 30;
        ems_voltage_percent_select(output_wave_data.ems_wave_percent);
    }
    // 变幅------------
    if(output_wave_data.one_cycle_run_cnt > 200)
    {

        if(0 == output_wave_data.one_cycle_run_cnt%5){
            ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
            ems_simulate_sine_wave();
            ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
        }     
    }

    if(output_wave_data.one_cycle_run_cnt > HAIR_MODE_EMS_TIME){
        output_wave_data.one_cycle_run_cnt = 0;
        ems_playlod1_stop();
        ems_output_disable(); 
    }
}
/**************
 * 
 * Ⅰ.EYE  眼部模式   EMS（低压电流敲打感）+vcsel红灯660nm+近红外1064nm——适用眼部唇部————
 *    PS：注意此模式要结合唇眼功能头的霍尔or带载检测识别才能点亮模式Ⅰ
 * 
 *   EMS 的power脚 不要切来切去，控制芯片可能随着power、脚失效
 *     切换频率时，ems 两个脚位 禁止同时为高电平
 * **/

static void je2_face_mode_waves(void)
{

    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;
    static uint8_t cur_ems_wave, cur_ems_freq;
    int max_rf_time;
    EMS_DUTY_LEVEL_e cur_ems_duty;


    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
//	set_sys_load_state(ON_LINE_STA);    // debug
#if 1       // 高周波检测负载	
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

  // 2024 10 22 修改逻辑，如果是运行过程中 负载离线了，则停止HF输出，EMS保持不变
    if((OFF_LINE_STA == get_sys_load_state()) && (0 == sys_data.cur_mode_active_online_flag)){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }
#else
    
#endif
    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                output_wave_data.motor_alarm_flag = 1;
            }
        }
    }
 
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        // if((output_wave_data.one_cycle_run_cnt % MAX_MODE_EMS_TIME) == 5){
        if((output_wave_data.one_cycle_run_cnt) == 100){
    #else
        if((output_wave_data.one_cycle_run_cnt % NEW_FACE_EMS_TIME) == 5){
    #endif  
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();

        ems_power_off();

    } 
    else{ //ems 开始
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        if(output_wave_data.one_cycle_run_cnt == 100 + 5){
    #else
        if((output_wave_data.one_cycle_run_cnt % NEW_FACE_EMS_TIME) == 100+5){
    #endif
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();
            set_sys_hf_flag(0);

            ems_power_off();
            ems_output_disable();

            cur_ems_wave ++;
            cur_ems_duty = level_ctrl_ems_duty();

            if(cur_ems_wave%4 == 0){
                cur_ems_freq ++;
            }
            switch(cur_ems_freq%2)
            {
                case 0:{
                    ems_freq_select_2khz(cur_ems_duty);
                    break;
                }
                case 1:{
                    ems_freq_select_3khz(cur_ems_duty);        //ems_freq_select_15khz
                    break;
                }
                default:{
                    ems_freq_select_3khz(cur_ems_duty); //ems_freq_select_3khz
                    break;
                }
            }
            ems_output_enable(); 
            ems_power_on();
            output_wave_data.ems_wave_percent =0;
            ems_voltage_percent_select(output_wave_data.ems_wave_percent);  

            //    printf("\n\r hair_wave_restart  \n\r");  
        }   // 开始变频 + 变压
        else if(output_wave_data.one_cycle_run_cnt > 100 + 5){


            if(output_wave_data.one_cycle_run_cnt%4 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                // ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                ems_simulate_sine_wave();
                ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
            }
        }
        if(output_wave_data.one_cycle_run_cnt > NEW_FACE_EMS_TIME){
            output_wave_data.one_cycle_run_cnt  = 0;
            output_wave_data.ems_wave_percent = 0;
            ems_playlod1_stop();
            ems_output_disable(); 
        }
    }
}



/**************
 * 
 * Ⅰ.EYE  眼部模式   EMS（低压电流敲打感）+vcsel红灯660nm+近红外1064nm——适用眼部唇部————
 *    PS：注意此模式要结合唇眼功能头的霍尔or带载检测识别才能点亮模式Ⅰ
 * 
 *   EMS 的power脚 不要切来切去，控制芯片可能随着power、脚失效
 *     切换频率时，ems 两个脚位 禁止同时为高电平
 * **/




static void je2_body_mode_waves(void)
{

    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;
    static uint8_t cur_ems_wave, cur_ems_freq;
    int max_rf_time;
    EMS_DUTY_LEVEL_e cur_ems_duty;


    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
//	set_sys_load_state(ON_LINE_STA);    // debug
#if 1       // 高周波检测负载	
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

  // 2024 10 22 修改逻辑，如果是运行过程中 负载离线了，则停止HF输出，EMS保持不变
    if((OFF_LINE_STA == get_sys_load_state()) && (0 == sys_data.cur_mode_active_online_flag)){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }
#else
    // ems 检测负载
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        ems_output_disable();
        return;
    }

    if(OFF_LINE_STA == get_sys_load_state()){
        if(output_wave_data.one_cycle_run_cnt%50==0){
            my_hf_wave_stop();
            hf_output_disable();

            ems_freq_select_4khz(EMS_LITTLE_DUTY);  // 斩脂刀时用4khz频率
            ems_output_enable();   
            ems_power_on();  
            ems_voltage_percent_select(100);
            set_sys_hf_flag(0);
            // printf(" \r\n ems_det_offline 111==== \r\n");
        }

        if(output_wave_data.one_cycle_run_cnt%50 < 5){
            ems_load_check();
        }

        if(output_wave_data.one_cycle_run_cnt%50 == 5){
            ems_playlod1_stop();
            ems_output_disable();  
        }
        last_load = 0;
        // set_sys_load_state(ON_LINE_STA); // debug
        return;   
    }
#endif



    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                output_wave_data.motor_alarm_flag = 1;
                hf_power_off();
                hf_output_disable();
                my_hf_wave_stop();
                output_wave_data.one_cycle_run_cnt= 5;
            }
        }
    }
    // //---持续检测部分
    // #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
    //     if((output_wave_data.one_cycle_run_cnt) < 100){

    //         if(output_wave_data.one_cycle_run_cnt == 80){
    //             my_hf_wave_stop();
    //             hf_output_disable();

    //             if(ON_LINE == get_zhan_zhi_dao_state()){
    //                 ems_freq_select_4khz(EMS_LITTLE_DUTY);
    //             }
    //             else{
    //                 cur_ems_duty = level_ctrl_ems_duty();
    //                 ems_freq_select_1khz(cur_ems_duty);
    //             }
    //             ems_output_enable();   
    //             ems_power_on();  
    //             ems_voltage_percent_select(100);
    //         }

    //         if((output_wave_data.one_cycle_run_cnt > 80)&&(output_wave_data.one_cycle_run_cnt < 95)){
    //             ems_load_check();
    //         }

    //         if(output_wave_data.one_cycle_run_cnt == 95){
    //             ems_playlod1_stop();
    //             ems_output_disable();  
    //         }
    //         return;
    //     }
    // #endif


 
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        // if((output_wave_data.one_cycle_run_cnt % MAX_MODE_EMS_TIME) == 5){
        if((output_wave_data.one_cycle_run_cnt) == 100){
    #else
        if((output_wave_data.one_cycle_run_cnt % BODY_MODE_EMS_TIME) == 5){
    #endif  
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();

        ems_power_off();

    } 
    else{ //ems 开始
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        if(output_wave_data.one_cycle_run_cnt == 100 + 5){
    #else
        if((output_wave_data.one_cycle_run_cnt % BODY_MODE_EMS_TIME) == 5 + 5){
    #endif
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();
            set_sys_hf_flag(0);

            ems_power_off();
            ems_output_disable();

            cur_ems_wave ++;
            cur_ems_duty = level_ctrl_ems_duty();

            if(cur_ems_wave%4 == 0){
                cur_ems_freq ++;
            }
            switch(cur_ems_freq%2)
            {
                case 0:{
                    ems_freq_select_2khz(cur_ems_duty);
                    break;
                }
                case 1:{
                    ems_freq_select_3khz(cur_ems_duty);        //ems_freq_select_15khz
                    break;
                }
                default:{
                    ems_freq_select_3khz(cur_ems_duty); //ems_freq_select_3khz
                    break;
                }
            }
            
            ems_power_on();
            output_wave_data.ems_wave_percent =0;
            ems_voltage_percent_select(output_wave_data.ems_wave_percent);  
            ems_output_enable(); 

            //    printf("\n\r hair_wave_restart  \n\r");  
        }   // 开始变频 + 变压
        else if(output_wave_data.one_cycle_run_cnt > 100 + 5){
            switch(cur_ems_wave%4){
                case 0:
                case 1:
                {
                    if(output_wave_data.one_cycle_run_cnt%4 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                        // ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                        ems_simulate_sine_wave();
                        ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
                    }
                    break;
                }

                case 2:
                case 3:
                {
                    if(output_wave_data.one_cycle_run_cnt%8 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                        // ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                        ems_simulate_sine_wave(); 
                        ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
                    }
                    break;
                }
                default:{
                    break;
                }
            }

            // if(output_wave_data.one_cycle_run_cnt%4 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
            //     // ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
            //     ems_simulate_sine_wave();
            //     ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
            // }
        }
        if(output_wave_data.one_cycle_run_cnt > BODY_MODE_EMS_TIME){
            output_wave_data.one_cycle_run_cnt  = 0;
            output_wave_data.ems_wave_percent = 0;
            ems_playlod1_stop();
            ems_output_disable(); 
        }
    }
}

/**************************************************************
 * 
 * Ⅰ.EYE  眼部模式   EMS（低压电流敲打感）+vcsel红灯660nm+近红外1064nm——适用眼部唇部————
 *    PS：注意此模式要结合唇眼功能头的霍尔or带载检测识别才能点亮模式Ⅰ
 * 
 *   EMS 的power脚 不要切来切去，控制芯片可能随着power、脚失效
 *     切换频率时，ems 两个脚位 禁止同时为高电平
 ***********************************************************/
static void je2_face_hair_mode_waves(void)
{

    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;
    static uint8_t cur_ems_wave, cur_ems_freq;
    int max_rf_time;
    static uint8_t ems_begin_time;
    EMS_DUTY_LEVEL_e cur_ems_duty;


    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
//	set_sys_load_state(ON_LINE_STA);    // debug
#if 1      // 高周波检测负载	
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }

  // 2024 10 22 修改逻辑，如果是运行过程中 负载离线了，则停止HF输出，EMS保持不变
    if((OFF_LINE_STA == get_sys_load_state()) && (0 == sys_data.cur_mode_active_online_flag)){
        hf_check_load_preiod();
        last_load = 0;
        return;
    }
#else
    
#endif



    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                output_wave_data.motor_alarm_flag = 1;
                hf_power_off();
                hf_output_disable();
                my_hf_wave_stop();
            }
        }
    }
    //---持续检测部分
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        if((output_wave_data.one_cycle_run_cnt) < 100){

            if(output_wave_data.one_cycle_run_cnt == 80){
                my_hf_wave_stop();
                hf_output_disable();

                if(ON_LINE == get_zhan_zhi_dao_state()){
                    ems_freq_select_4khz(EMS_LITTLE_DUTY);
                }
                else{
                    cur_ems_duty = level_ctrl_ems_duty();
                    ems_freq_select_1khz(cur_ems_duty);
                }
                ems_output_enable();   
                ems_power_on();  
                ems_voltage_percent_select(100);
            }

            if((output_wave_data.one_cycle_run_cnt > 80)&&(output_wave_data.one_cycle_run_cnt < 95)){
                ems_load_check();
            }

            if(output_wave_data.one_cycle_run_cnt == 95){
                ems_playlod1_stop();
                ems_output_disable();  
            }
            return;
        }
    #endif


 
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        // if((output_wave_data.one_cycle_run_cnt % MAX_MODE_EMS_TIME) == 5){
        if((output_wave_data.one_cycle_run_cnt) == 100){
            ems_begin_time = 100;
    #else
        if((output_wave_data.one_cycle_run_cnt % HAIR_MODE_EMS_TIME) == 5){
            ems_begin_time = 50;
    #endif  
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();

        ems_power_off();

    } 
    else{ //ems 开始
        if(output_wave_data.one_cycle_run_cnt == ems_begin_time + 5){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();
            set_sys_hf_flag(0);

            ems_power_off();
            ems_output_disable();

            cur_ems_wave ++;
            cur_ems_duty = level_ctrl_ems_duty();

            if(cur_ems_wave%4 == 0){
                cur_ems_freq ++;
            }
            switch(cur_ems_freq%2)
            {
                case 0:{
                    ems_freq_select_2khz(cur_ems_duty);
                    break;
                }
                case 1:{
                    ems_freq_select_3khz(cur_ems_duty);        //ems_freq_select_15khz
                    break;
                }
                default:{
                    ems_freq_select_3khz(cur_ems_duty); //ems_freq_select_3khz
                    break;
                }
            }
            ems_output_enable(); 
            ems_power_on();
            output_wave_data.ems_wave_percent =30;
            ems_voltage_percent_select(30);  

            //    printf("\n\r hair_wave_restart  \n\r");  
        }   // 开始变频 + 变压
        else if(output_wave_data.one_cycle_run_cnt > ems_begin_time + 5){

            if(output_wave_data.one_cycle_run_cnt%5 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                if(output_wave_data.ems_wave_percent < 100){
                    ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                    ems_simulate_sine_wave();
                    ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
                }

            }
        }
        if(output_wave_data.one_cycle_run_cnt > HAIR_MODE_EMS_TIME){
            output_wave_data.one_cycle_run_cnt  = 0;
            output_wave_data.ems_wave_percent = 0;
            ems_playlod1_stop();
            ems_output_disable(); 
        }
    }
}



/**************
 * 
 * Ⅰ.EYE  眼部模式   EMS（低压电流敲打感）+vcsel红灯660nm+近红外1064nm——适用眼部唇部————
 *    PS：注意此模式要结合唇眼功能头的霍尔or带载检测识别才能点亮模式Ⅰ
 * 
 *   EMS 的power脚 不要切来切去，控制芯片可能随着power、脚失效
 *     切换频率时，ems 两个脚位 禁止同时为高电平
 * **/




static void max_mode_waves(void)
{

    static uint8_t hight_vol_hold_time = 0; 
    static uint8_t last_load;
    static uint8_t cur_ems_wave, cur_ems_freq;
    int max_rf_time;
    EMS_DUTY_LEVEL_e cur_ems_duty;

#if 1
    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
    // 负载不再线 或输出短路时检测，输出少量的 HF进行 负载检测
    // 每100ms 输出 20ms
//	set_sys_load_state(ON_LINE_STA);    // debug

    // ems 检测负载
    if(SHORT_CIRCLE_STA == get_sys_load_state()){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();
        ems_output_disable();
        return;
    }

    if(OFF_LINE_STA == get_sys_load_state()){
        if(output_wave_data.one_cycle_run_cnt%50==0){
            my_hf_wave_stop();
            hf_output_disable();

            // cur_ems_duty = level_ctrl_ems_duty();
            // ems_freq_select_1khz(cur_ems_duty);
            ems_freq_select_4khz(EMS_LITTLE_DUTY);  // 斩脂刀时用4khz频率
            
            ems_output_enable();   
            ems_power_on();  
            ems_voltage_percent_select(100);
            set_sys_hf_flag(0);
            // printf(" \r\n ems_det_offline 111==== \r\n");
        }

        if(output_wave_data.one_cycle_run_cnt%50 < 5){
            ems_load_check();
        }

        if(output_wave_data.one_cycle_run_cnt%50 == 5){
            ems_playlod1_stop();
            ems_output_disable();  
        }
        last_load = 0;

        // set_sys_load_state(ON_LINE_STA); // debug
        return;   
    }
#else 


#endif

    if(last_load != get_sys_load_state()){
        last_load = get_sys_load_state();
        
        if(last_load){
            if(0 == output_wave_data.motor_alarm_flag){
                motor_shor_on();
                output_wave_data.motor_alarm_flag = 1;
            }
        } 
    }
    //---持续检测部分
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        if((output_wave_data.one_cycle_run_cnt) < 100){

            if(output_wave_data.one_cycle_run_cnt == 80){
                my_hf_wave_stop();
                hf_output_disable();

                if(ON_LINE == get_zhan_zhi_dao_state()){
                    ems_freq_select_4khz(EMS_LITTLE_DUTY);
                }
                else{
                    cur_ems_duty = level_ctrl_ems_duty();
                    ems_freq_select_1khz(cur_ems_duty);
                }
                ems_output_enable();   
                ems_power_on();  
                ems_voltage_percent_select(100);
                // set_sys_hf_flag(0);
                // printf(" \r\n ems_det_offline 111==== \r\n");
            }

            if((output_wave_data.one_cycle_run_cnt > 80)&&(output_wave_data.one_cycle_run_cnt < 95)){
                ems_load_check();
            }

            if(output_wave_data.one_cycle_run_cnt == 95){
                ems_playlod1_stop();
                ems_output_disable();  
            }
            return;
        }
    #endif


 
    #if (LOAD_CHECK_MODE == ONE_MODE_CONTIUNE_CHECK)
        // if((output_wave_data.one_cycle_run_cnt % MAX_MODE_EMS_TIME) == 5){
        if((output_wave_data.one_cycle_run_cnt) == 100){
    #else
        if((output_wave_data.one_cycle_run_cnt % MAX_MODE_EMS_TIME) == 5){
    #endif  
        hf_power_off();
        hf_output_disable();
        my_hf_wave_stop();

        ems_power_off();

    } 
    else{ //ems 开始
        if(output_wave_data.one_cycle_run_cnt == 100 + 5){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();
            set_sys_hf_flag(0);

            ems_power_off();
            ems_output_disable();
            // ems_freq_select_9khz();
            cur_ems_wave ++;
            cur_ems_duty = level_ctrl_ems_duty();

            if(cur_ems_wave%4 == 0){
                cur_ems_freq ++;
            }
            switch(cur_ems_freq%2)
            {
                case 0:{
                    ems_freq_select_2khz(cur_ems_duty);
                    break;
                }
                case 1:{
                    ems_freq_select_3khz(cur_ems_duty);        //ems_freq_select_15khz
                    break;
                }

                
                default:{
                    ems_freq_select_3khz(cur_ems_duty); //ems_freq_select_3khz
                    break;
                }
            }
            ems_output_enable(); 
            ems_power_on();
            output_wave_data.ems_wave_percent =30;
            ems_voltage_percent_select(30);  

            //    printf("\n\r hair_wave_restart  \n\r");  
        }   // 开始变频 + 变压
        else if(output_wave_data.one_cycle_run_cnt > 100 + 5){
#if 0

#else

        switch(cur_ems_wave%4){
            case 0:
            case 1:
            {
                if(output_wave_data.one_cycle_run_cnt%10 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                    ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                    ems_simulate_sine_wave();
                    ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
                }
                break;
            }

            case 2:
            case 3:
            {
                if(output_wave_data.one_cycle_run_cnt%10 == 0){ // 10ms减去一次 HAIR_MODE_HF_TIME
                    ems_voltage_percent_select(0);      // 防止ems电压切换时，出现毛刺，现将电压设置为0%  2024 10 21
                    ems_simulate_sine_wave(); 
                    ems_voltage_percent_select(output_wave_data.ems_wave_percent); 
                }
                break;
            }
            default:{
                break;
            }
        }

#endif
        }
        if(output_wave_data.one_cycle_run_cnt > MAX_MODE_EMS_TIME){
            output_wave_data.one_cycle_run_cnt  = 0;
            output_wave_data.ems_wave_percent = 0;
            ems_playlod1_stop();
            ems_output_disable(); 
        }
    }
}




/*
    测试模式 高周波
*/
static void test_hf_mode_wave(void)
{


}


/*
    测试模式 ems 3khz
*/
static void test_ems_3khz_mode_wave(void)
{

    
}
/*
    测试模式 ems 9khz
*/
static void test_ems_9khz_mode_wave(void)
{

    
}
/*
    测试模式 ems 12khz
*/
static void test_ems_12khz_mode_wave(void)
{

    
}

/*
    测试模式 ems 15khz
*/
static void test_ems_15khz_mode_wave(void)
{

    
}


// 满duty 25ms ，一个整小周期
//-----------------------    lv0, lv1,lv2,3,  4,  5,  6,  7,  8,  9, 10        
int hf_level_duty_array[11] = {5, 15, 18, 20, 21, 22, 22, 23, 23, 24, 24}; 
/********************************************************************************
 * 高周波 共持续1s， ems 共持续2s这样的时序进行切换
 * 
 *  高周波细分： 单个周期25ms， duty 可以氛围 10~ 15， 每2档增加一个duty
 *  ems ：进行频率切换 9k~20khz
 * 每1ms进入一次
 * 
 *******************************************************************************/ 
void je3_output_ctrl(void)
{
    static uint8_t last_sta = 0xff;
    static uint8_t last_mode = 0;
    static uint8_t level_0_close_output_flag = 0;

    output_wave_data.one_cycle_run_cnt ++;

    if((SLEEP_STA == get_sys_state()) || (CHARGE_STA == get_sys_state())|| (CHARGE_FINISH_STA == get_sys_state())){
        if(last_sta != sys_data.sta){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();

			ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            ems_power_en_off();
            
            last_sta = sys_data.sta;
        }
        return;
    }
    last_sta = get_sys_state();
    if(output_wave_data.one_cycle_run_cnt == 5){
        // printf("HF hf_load_adc[%d],hf_vcc_adc[%d] ----\r\n", output_wave_data.hf_load_adc, output_wave_data.hf_vcc_adc);
    }

      // 切换模式时， 先关闭输出   
    if (last_mode != get_sys_mode()){
        hf_power_off();
        my_hf_wave_stop();
        hf_output_disable();

        ems_power_off();
        ems_playlod1_stop();
        ems_output_disable();
        last_mode = get_sys_mode();
        set_sys_load_state(OFF_LINE_STA);        // 切换模式时，变为离线状态
        output_wave_data.one_cycle_run_cnt = 0;
        output_wave_data.motor_alarm_flag = 0;
        // ems_voltage_percent_select(100);
        printf("\r\n  mode change\r\n");
    }


    // 0 档开机时，无任何输出
    if(LEVEL_0 == get_sys_level()){
        if(0 == level_0_close_output_flag){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();

            ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            level_0_close_output_flag = 1;
            set_sys_hf_flag(0);
            printf("\r\n sys_lvl0 ,close all output \r\n");
        }
        output_wave_data.one_cycle_run_cnt = 0;
        return;
    }
 
    level_0_close_output_flag = 0;

    /******************************************
     * 老化模式，运行5min，暂停5min。 担心硬件持续工作扛不住
     * */ 
    if(ALIGN_STA == get_sys_state())
    {
       if(sys_data.aling_run_cnt > ALING_MODE_MAX_OUT_TIME){
            if(sys_data.aling_run_cnt >= ALING_MODE_MAX_OUT_TIME + ALING_MODE_MAX_STOP_TIME)
            {
                sys_data.aling_run_cnt = 0;
                output_wave_data.one_cycle_run_cnt = 0;
                return;
            }
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();

			ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            return;
       }
    }

    /******************************************
     * 老化模式，处理结束 * */ 
     
    // 不同模式在这里选择输出波形
    switch(get_sys_mode())
    {
        case FACE_MODE:{
            je2_face_mode_waves();
            break;
        }
        case BODY_MODE:{
            je2_body_mode_waves();

            break;
        }
        case HAIR_MODE:{
            je2_face_hair_mode_waves();
            break;
        }
        case MAX_MODE:{
            body_mode_waves();
            break;
        }
        case TEST_ONLY_EMS_MODE:{
            ems_freq_const_vcc_select(EMS_2KHZ_FREQ);
            break;
        }
        case TEST_ONLY_RF_MODE:{
            only_RF_wave_test();
            break;
        }
        default:{
            break;
        }
    }
}

/********************************************************************************
 * JX1 输出判断
 * 
 * 
 *******************************************************************************/ 

void jx1_my_output_ctrl(void)
{
    static uint8_t wear_head_check_delay = 0;    // 佩戴头检测delay
    static uint8_t last_module = 0xff;
    static uint8_t last_sta = 0xff; 

    output_wave_data.one_cycle_run_cnt ++;

    if((SLEEP_STA == get_sys_state()) || (CHARGE_STA == get_sys_state())|| (CHARGE_FINISH_STA == get_sys_state())){
        if(last_sta != sys_data.sta){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();

			ems_power_off();
            ems_playlod1_stop();
            ems_output_disable();
            ems_power_en_off();
            // 停止输出----   
            last_sta = sys_data.sta;
        }
        return;
    }

    wear_head_check_delay ++;
    // 10ms 读取一次
    // if(0 == wear_head_check_delay%10){
    //     wear_mode_active_check(my_wear_module_adc_read());
    // }

    // 切换模式时，关闭输出
    if(last_module != get_wear_module_state()){
            hf_power_off();
            my_hf_wave_stop();
            hf_output_disable();

            ems_power_on();
            ems_playlod1_restar();
            ems_output_enable();
            motor_fe_stop();
            output_wave_data.one_cycle_run_cnt = 0;
    }

    switch(get_wear_module_state()){
        case WEAR_OFFLINE_MODULE:{

            break;
        }
        case WEAR_MOTOR_MODULE:{
            if(output_wave_data.one_cycle_run_cnt== 10){
                // motor_fe_start();
                printf("motor_restart \r\n");
            }
            if(output_wave_data.one_cycle_run_cnt>= 1000){
               
                output_wave_data.one_cycle_run_cnt = 0;
                
            }

            break;
        }
        case WEAR_FE_MODULE:{
            body_mode_waves();

            break;
        }
        default:{

            break;
        }
    }
    last_module = get_wear_module_state();
}
